def file_handler(yongshen, textfile, read_lines=None) -> list[dict]:
    '''
    传入六爻代码文本，返回词典示例：
    [
        {'断语1': [['官鬼', '月扶', '空亡'], ['子孙伏藏']]},
        {'断语2': [['官鬼化出', '月建', '空亡']]}
    ]
    能够支持的文本逻辑：
    obj：详见代码
    string：A或B或C
    不同obj：一个句子用“，”分割
    断语：条件 “：” 断语 “。”
    '''

    def get_articles():
        # 检查格式，移除注释；根据用神，替代关键字
        bigtext = remove_comments(textfile)
        bigtext = replace_yongshen(yongshen, bigtext)

        # 按句分割文本，句号为一个完整条文单位。article：一条条文，如“官鬼 发动：有人偷。妻财 发动：自己不见了。”
        articles = [line.strip() for line in bigtext.split('。') if line.strip() and "：" in line]
        return articles

    if textfile.endswith('.json'):
        load_data = read_json(textfile)
        for str_num, article in load_data.items():
            conditions = replace_yongshen(yongshen, article['条件'])
            conditions, sayings = conditions.split('|'), article['断语'].split('|')
            tmp_dic = {}
            for condition, saying in zip(conditions, sayings):
                condition_section = [section for section in condition.strip().split('，') if section]
                加工过的条件 = []

                for 子条件 in condition_section:
                    加工过的条件.append([item for item in 子条件.split(' ') if item])
                tmp_dic[saying.strip()] = 加工过的条件
            yield tmp_dic

    else:
        articles = get_articles()
        for article in articles:  # TODO:【bug】这里debug会闪退
            if article.startswith('·') and read_lines:
                read_lines(article)
                continue
                # 满足识别的条件，转跳到高级的循环。不必进行下文的处理。

            tmp_dict = {}
            sub_articles = article.split('|')  # sub_articles：分条文，如：“官鬼 发动：有人偷”
            for sub_article in sub_articles:

                # 以冒号作为分割，分为条件和断语
                if "：" in sub_article:
                    idx = sub_article.index("：")
                    condition, saying = sub_article[:idx].strip(), sub_article[idx + 1:]
                else:
                    print('此子条文不包含冒号。', sub_article)
                    break

                # 条件按分号分割，得到分割单元列表，  # if section:防止有空白section
                condition_section = [section for section in condition.split('，') if section]

                加工过的条件 = []
                for 子条件 in condition_section:
                    加工过的条件.append([item for item in 子条件.split(' ') if item])  # if item:空格 cannot be a verb

                tmp_dict[saying] = 加工过的条件
            yield tmp_dict


'''处理文本的辅助函数'''


def remove_comments(textfile):
    import re
    with open(textfile, 'r', encoding='utf-8') as f:
        bigtext = f.read()

    pattern = r"(/\*.*?\*/|//.*?$)"
    regex = re.compile(pattern, re.MULTILINE | re.DOTALL)

    return regex.sub("", bigtext)


def replace_yongshen(yongshen, bigtext):
    # requirement: yongshen in value_dict
    # function:replace some name in BigText with 'yongshen'

    value_lis = ['父母', '兄弟', '子孙', '妻财', '官鬼']  # [定位]世爻元神，怎么替代？
    value_dict = {'用神': '妻财', '闲神': '官鬼', '仇神': '父母', '忌神': '兄弟', '元神': '子孙'}
    if any(key in bigtext for key in value_dict.keys()):

        if yongshen != '妻财' and yongshen in value_lis:
            idx = value_lis.index(yongshen)
            value_dict = {'用神': value_lis[idx], '闲神': value_lis[(idx + 1) % 5],
                          '仇神': value_lis[(idx + 2) % 5],
                          '忌神': value_lis[(idx + 3) % 5], '元神': value_lis[(idx + 4) % 5]}
        for k, v in value_dict.items():
            bigtext = bigtext.replace(k, v)
    return bigtext


'''编码卦象，以便查找csv'''


# encode_gua_image
def get_path_idx(trigger_li: list[int], gua_num: int):
    import os
    # get this status's idx
    n = sum(trigger_li)

    if n == 1:
        path = 'load_csv/Gua_OneLineVary.csv'  # TODO:路径变化，检查是否存在文件
        idx = trigger_li.index(1) + 7  # 前6列是阴阳，用于定位一个卦；从第7列开始选择
        # example:6爻发动为0，table's column is 对应7；1爻发动为5，table's column is 12
    elif n == 2:
        # path = 'load_csv/Gua_MutiLineVary.csv'
        # idx = coins_to_idx(self.trigger_li, n) + 7
        path = 'load_csv/二爻动.csv'
        idx = trigger_list_to_idx(trigger_li, n) + 1
    elif n == 3:
        path = 'load_csv/三爻动.csv'
        idx = trigger_list_to_idx(trigger_li, n) + 1
    elif n == 4:
        path = 'load_csv/四爻动.csv'
        idx = trigger_list_to_idx(trigger_li, n) + 1
    elif n == 5:
        path = 'load_csv/五爻动.csv'
        idx = trigger_li.index(0) + 1
    else:
        return None

    if 1 <= n <= 5:
        # 检查文件是否存在
        if not os.path.exists(path):
            # 如果文件不存在，则创建文件
            with open(path, 'w', encoding='utf-8') as file:
                # 写入空字符串，代表创建了一个空文件
                file.write('')

        return (path, gua_num + 2, idx)


# encode_trigger_lst
def trigger_list_to_idx(li, n) -> int:
    '''
    计算这个动变的序号。（二爻动，三爻动，四爻动）
    :param li: trigger_list,只有0和1的6位列表。
    :param n: trigger_list为1的个数。
    :return: 序号。
    '''
    # requirement:all(num in [0,1] for num in li),len(li)==6
    li = list(reversed(li))  # 反转变成：[初爻，二爻，三爻，四爻，五爻，六爻]
    if n in [2, 4]:
        idx_1, idx_2 = [i for i, value in enumerate(li) if value == (n / 2) % 2]  # 2==>1,4==>0
        bi_vary_initial_table = [-1, 3, 6, 8, 9]
        return bi_vary_initial_table[idx_1] + idx_2
    elif n == 3:
        idx_1, idx_2, idx_3 = [i for i, value in enumerate(li) if value == 1]
        initial_table = {  # all possible status of [ idx_1, idx_2, idx_3 ]
            (0, 1): -2, (0, 2): 1, (0, 3): 3, (0, 4): 4,
            (1, 2): 7, (1, 3): 9, (1, 4): 10,
            (2, 3): 12, (2, 4): 13, (3, 4): 14
        }
        return initial_table[(idx_1, idx_2)] + idx_3


'''读取json csv'''


def read_json(file_path):
    import json
    try:
        with open(file_path, 'r', encoding='utf-8') as file:
            file_content = file.read()
            if not file_content.strip():  # 检查文件是否为空
                print("文件为空，已设置默认值。")
                return

        with open(file_path, 'r', encoding='utf-8') as file:
            loaded_data = json.load(file)
            # 验证加载的JSON数据格式
            if isinstance(loaded_data, dict) and (k.isdigit() and set(v.keys()) != {'条件', '注释', '断语'}
                                                  for k, v in loaded_data.items()):
                return loaded_data
            else:
                print("加载的JSON数据格式不符合要求。")

    except json.JSONDecodeError:
        print("文件不是有效的JSON格式。")


def read_specific_cell(csv_file, row_number, column_number):
    # 读取词典的某个单元格，节省内存
    try:
        with open(csv_file, 'r', encoding='gbk', newline='') as file:
            reader = csv.reader(file)
            for i, row in enumerate(reader):
                if i + 1 == row_number:  # 找到指定行
                    if column_number <= len(row):  # 确保指定的列存在于该行中
                        return row[column_number - 1]  # 返回指定列的数据
    except FileNotFoundError:
        if not os.path.exists(csv_file):
            # 如果路径不存在，创建路径
            os.makedirs(csv_file)
            with open(csv_file, 'w', encoding='gbk') as file:
                file.write('六,五,四,三,二,初')
                print(f"{csv_file}文件不存在！已为您自动创建...")


# explain_cell_params
def text_output_func(cell_params: list[tuple]) -> None:
    """
    这是在给定的csv专门查条文的函数。
    需要吻合csv构造的行列。
    """

    def dedigit(sentence: str):
        # 条文如果是数字，筛选掉；不是数字，加格式。
        if sentence and not sentence.isdigit():  # 找到的条文不是空值，也不是数值；加格式。
            sentence = f"◇{sentence.strip()}\n"
            return sentence
        return None

    articles = []

    for params in cell_params:  # 这里提供了表格的行列参数
        try:
            cell = read_specific_cell(*params)
            if wd := dedigit(cell):
                articles.append(wd)
        except Exception as e:
            print(params[0], e, "，text_output_func 出错了。")

    for sentence in articles:
        print(sentence)

    # return articles
